# -*- mode: perl; tab-width: 2 -*-
# Configure options for the generic language support

{

	# Options to always feed to ectags
	'ectagsopts' => [
		"--options=" . $config->ectagsconf, "--c-types=+px",
		"--eiffel-types=+l",                "--fortran-types=+L",
	],

	# How to map a language name to the ectags language-force name
	# if there is no mapping, then the language name is used
	'eclangnamemapping' => {
		'C'      => 'c',
		'C++'    => 'c++',
		'Python' => 'python',
		'SQL'    => 'SQL2',
		'shell'  => 'sh',
	},

	# lang map specifies info for each language
	# what the reserved words & comment chars are
	'langmap' => {
		'C' => {
			'reserved' => [
				'auto',     'break',  'case',    'char',   'const',    'continue',
				'default',  'do',     'double',  'else',   'enum',     'extern',
				'float',    'for',    'goto',    'if',     'int',      'long',
				'register', 'return', 'short',   'signed', 'sizeof',   'static',
				'struct',   'switch', 'typedef', 'union',  'unsigned', 'void',
				'volatile', 'while',
			],

			'spec' => [
				'atom',    '\\\\.', '',   'comment', '/\*',         '\*/',
				'comment', '//',    "\$", 'string',  '"',           '"',
				'string',  "'",     "'",  'include', '#\s*include', "\$"
			],

			'typemap' => {
				'c' => 'class',
				'd' => 'macro (un)definition',
				'e' => 'enumerator',
				'f' => 'function definition',
				'g' => 'enumeration name',
				'i' => 'interface',
				'm' => 'class, struct, or union member',
				'n' => 'namespace',
				'p' => 'function prototype or declaration',
				's' => 'structure name',
				't' => 'typedef',
				'u' => 'union name',
				'v' => 'variable definition',
				'x' => 'extern or forward variable declaration',
			},
			'langid' => '1',
		},

		'C++' => {
			'reserved' => [
				'and',         'and_eq',     'asm',              'auto',
				'bitand',      'bitor',      'bool',             'break',
				'case',        'catch',      'char',             'class',
				'const',       'const_cast', 'continue',         'default',
				'delete',      'do',         'double',           'dynamic_cast',
				'else',        'enum',       'explicit',         'export',
				'extern',      'false',      'float',            'for',
				'friend',      'goto',       'if',               'inline',
				'int',         'long',       'mutable',          'namespace',
				'new',         'not',        'not_eq',           'operator',
				'or',          'or_eq',      'private',          'protected',
				'public',      'register',   'reinterpret_cast', 'return',
				'short',       'signed',     'sizeof',           'static',
				'static_cast', 'struct',     'switch',           'template',
				'this',        'throw',      'true',             'try',
				'typedef',     'typeid',     'typename',         'union',
				'unsigned',    'using',      'virtual',          'void',
				'volatile',    'wchar_t',    'while',            'xor',
				'xor_eq'
			],

			'spec' => [
				'atom',    '\\\\.', '',   'comment', '/\*',         '\*/',
				'comment', '//',    "\$", 'string',  '"',           '"',
				'string',  "'",     "'",  'include', '#\s*include', "\$"
			],
			'typemap' => {
				'c' => 'class',
				'd' => 'macro (un)definition',
				'e' => 'enumerator',
				'f' => 'function definition',
				'g' => 'enumeration name',
				'i' => 'interface',
				'm' => 'class, struct, or union member',
				'n' => 'namespace',
				'p' => 'function prototype or declaration',
				's' => 'structure name',
				't' => 'typedef',
				'u' => 'union name',
				'v' => 'variable definition',
				'x' => 'extern or forward variable declaration',
			},
			'langid' => '2',

		},

        
		'C#' => {
			'reserved' => [
				'abstract', 	'event', 	'new', 		'struct',
				'as', 		'explicit', 	'null', 	'switch',
				'base', 	'extern', 	'object', 	'this',
				'bool', 	'false', 	'operator', 	'throw',
				'break', 	'finally', 	'out', 		'true',
				'byte', 	'fixed', 	'override', 	'try',
				'case', 	'float', 	'params', 	'typeof',
				'catch', 	'for', 		'private', 	'uint',
				'char', 	'foreach', 	'protected', 	'ulong',
				'checked', 	'goto', 	'public', 	'unchecked',
				'class', 	'if', 		'readonly', 	'unsafe',
				'const', 	'implicit', 	'ref', 		'ushort',
				'continue', 	'in',		'return', 	'using',
				'decimal', 	'int', 		'sbyte', 	'virtual',
				'default', 	'interface', 	'sealed', 	'volatile',
				'delegate', 	'internal', 	'short', 	'void',
				'do', 		'is', 		'sizeof', 	'while',
				'double', 	'lock', 	'stackalloc',	'else',
				'long', 	'static', 	'enum',		'namespace',
				'string'
			],

			'spec' => [
				'atom'    => ('\\\\.',   ''),
				'comment' => ('/\*',     '\*/'),
				'comment' => ('//',      "\$"),
				'string'  => ('"',       '"'),
				'string'  => ("'",       "'"),
				'include' => ('using',  "\$"),
			],
			'typemap' => {
				'c' => 'classes',
                'd' => 'macro definitions',
                'e' => 'enumerators',
                'E' => 'events',
                'f' => 'fields',
                'g' => 'enumeration names',
                'i' => 'interfaces',
                'l' => 'local variables',
                'm' => 'methods',
                'n' => 'namespaces',
                'p' => 'properties',
                's' => 'structure names',
                't' => 'typedefs'
			},
			'langid' => '5',
		},

		'Java' => {
			'reserved' => [
				'break',        'case',      'continue', 'default',
				'do',           'else',      'for',      'goto',
				'if',           'return',    'static',   'switch',
				'void',         'volatile',  'while',    'public',
				'class',        'final',     'private',  'protected',
				'synchronized', 'package',   'import',   'boolean',
				'byte',         'new',       'abstract', 'extends',
				'implements',   'interface', 'throws',   'instanceof',
				'super',        'this',      'native',   'null'
			],

			'spec' => [
				'atom'    => ('\\\\.',   ''),
				'comment' => ('/\*',     '\*/'),
				'comment' => ('//',      "\$"),
				'string'  => ('"',       '"'),
				'string'  => ("'",       "'"),
				'include' => ('import',  "\$"),
				'include' => ('package', "\$"),
			],
			'typemap' => {
				'c' => 'class',
				'f' => 'field',
				'i' => 'interface',
				'm' => 'method',
				'p' => 'package',
			},
			'langid' => '3',
		},

		'Fortran' => {
			'reserved' => [],
			'typemap'  => {
				'b' => 'block data',
				'c' => 'common block',
				'e' => 'entry point',
				'f' => 'function',
				'i' => 'interface',
				'k' => 'type component',
				'l' => 'label',
				'L' => 'local and common block variable',
				'm' => 'module',
				'n' => 'namelist',
				'p' => 'program',
			},
			'langid' => '4',
		},

		'Pascal' => {
			'reserved' => [],
			'langid'   => '5',
		},

		'Cobol' => {
			'reserved' => [

				# other
				'LIKE',
				'END-IF',

				# ansi
				'ACCEPT',
				'ACCESS',
				'ADD',
				'ADVANCING',
				'AFTER',
				'ALL',
				'ALPHABET',
				'ALPHABETIC',
				'ALPHABETICLOWER',
				'ALPHABETICUPPER',
				'ALPHANUMERIC',
				'ALPHANUMERICEDITED',
				'ALSO',
				'ALTER',
				'ALTERNATE',
				'AND',
				'ANY',
				'ARE',
				'AREA',
				'AREAS',
				'ASCENDING',
				'ASSIGN',
				'AT',
				'AUTHOR',
				'BEFORE',
				'BINARY',
				'BLANK',
				'BLOCK',
				'BOTTOM',
				'BY',
				'CALL',
				'CANCEL',
				'CD',
				'CF',
				'CH',
				'CHARACTER',
				'CHARACTERS',
				'CLASS',
				'CLOCKUNITS',
				'CLOSE',
				'COBOL',
				'CODE',
				'CODESET',
				'COLLATING',
				'COLUMN',
				'COMMA',
				'COMMON',
				'COMMUNICATION',
				'COMP',
				'COMP0',
				'COMP1',
				'COMP2',
				'COMP3',
				'COMP4',
				'COMP5',
				'COMP6',
				'COMPUTATIONAL',
				'COMPUTATIONAL0',
				'COMPUTATIONAL1',
				'COMPUTATIONAL2',
				'COMPUTATIONAL3',
				'COMPUTATIONAL4',
				'COMPUTATIONAL5',
				'COMPUTATIONAL6',
				'COMPUTATIONALX',
				'COMPUTE',
				'COMPX',
				'CONFIGURATION',
				'CONTAINS',
				'CONTENT',
				'CONTINUE',
				'CONTROL',
				'CONTROLAREA',
				'CONTROLS',
				'CONVERTING',
				'COPY',
				'CORR',
				'CORRESPONDING',
				'COUNT',
				'CURRENCY',
				'DATA',
				'DATE',
				'DATECOMPILED',
				'DATEWRITTEN',
				'DAY',
				'DAYOFWEEK',
				'DE',
				'DEBUGCONTENTS',
				'DEBUGGING',
				'DEBUGITEM',
				'DEBUGLINE',
				'DEBUGNAME',
				'DEBUGSUB1',
				'DEBUGSUB2',
				'DEBUGSUB3',
				'DECIMALPOINT',
				'DECLARATIVES',
				'DELETE',
				'DELIMITED',
				'DELIMITER',
				'DEPENDING',
				'DESCENDING',
				'DESTINATION',
				'DETAIL',
				'DISABLE',
				'DISPLAY',
				'DIVIDE',
				'DIVISION',
				'DOWN',
				'DUPLICATES',
				'DYNAMIC',
				'EGI',
				'ELSE',
				'EMI',
				'ENABLE',
				'END',
				'ENDADD',
				'ENDCALL',
				'ENDCOMPUTE',
				'ENDDELETE',
				'ENDDIVIDE',
				'ENDEVALUATE',
				'ENDIF',
				'ENDMULTIPLY',
				'ENDOFPAGE',
				'ENDPERFORM',
				'ENDREAD',
				'ENDRECEIVE',
				'ENDRETURN',
				'ENDREWRITE',
				'ENDSEARCH',
				'ENDSTART',
				'ENDSTRING',
				'ENDSUBTRACT',
				'ENDUNSTRING',
				'ENDWRITE',
				'ENTER',
				'ENVIRONMENT',
				'EOP',
				'EQUAL',
				'ERROR',
				'ESI',
				'EVALUATE',
				'EVERY',
				'EXCEPTION',
				'EXIT',
				'EXTEND',
				'EXTERNAL',
				'FALSE',
				'FD',
				'FILE',
				'FILECONTROL',
				'FILLER',
				'FINAL',
				'FIRST',
				'FOOTING',
				'FOR',
				'FROM',
				'FUNCTION',
				'GENERATE',
				'GIVING',
				'GLOBAL',
				'GO',
				'GREATER',
				'GROUP',
				'HEADING',
				'HIGHVALUE',
				'HIGHVALUES',
				'IDENTIFICATION',
				'IF',
				'IN',
				'INDEX',
				'INDEXED',
				'INDICATE',
				'INITIAL',
				'INITIALIZE',
				'INITIATE',
				'INPUT',
				'INPUTOUTPUT',
				'INSPECT',
				'INSTALLATION',
				'INTO',
				'INVALID',
				'IO',
				'IOCONTROL',
				'JUST',
				'JUSTIFIED',
				'KEY',
				'LABEL',
				'LAST',
				'LEADING',
				'LEFT',
				'LENGTH',
				'LESS',
				'LIMIT',
				'LIMITS',
				'LINAGE',
				'LINAGECOUNTER',
				'LINE',
				'LINECOUNTER',
				'LINES',
				'LINKAGE',
				'LOCK',
				'LOWVALUE',
				'LOWVALUES',
				'MEMORY',
				'MERGE',
				'MESSAGE',
				'MODE',
				'MODULES',
				'MORELABELS',
				'MOVE',
				'MULTIPLE',
				'MULTIPLY',
				'NATIVE',
				'NEGATIVE',
				'NEXT',
				'NO',
				'NOT',
				'NUMBER',
				'NUMERIC',
				'NUMERICEDITED',
				'OBJECTCOMPUTER',
				'OCCURS',
				'OF',
				'OFF',
				'OMITTED',
				'ON',
				'OPEN',
				'OPTIONAL',
				'OR',
				'ORDER',
				'ORGANIZATION',
				'OTHER',
				'OUTPUT',
				'OVERFLOW',
				'PACKEDDECIMAL',
				'PADDING',
				'PAGE',
				'PAGECOUNTER',
				'PERFORM',
				'PF',
				'PH',
				'PIC',
				'PICTURE',
				'PLUS',
				'POINTER',
				'POSITION',
				'POSITIVE',
				'PRINTING',
				'PROCEDURE',
				'PROCEDURES',
				'PROCEED',
				'PROGRAM',
				'PROGRAMID',
				'PURGE',
				'QUEUE',
				'QUOTE',
				'QUOTES',
				'RANDOM',
				'RD',
				'READ',
				'RECEIVE',
				'RECORD',
				'RECORDS',
				'REDEFINES',
				'REEL',
				'REFERENCE',
				'REFERENCES',
				'RELATIVE',
				'RELEASE',
				'REMAINDER',
				'REMOVAL',
				'RENAMES',
				'REPLACE',
				'REPLACING',
				'REPORT',
				'REPORTING',
				'REPORTS',
				'RERUN',
				'RESERVE',
				'RETURN',
				'REVERSED',
				'REWIND',
				'REWRITE',
				'RF',
				'RH',
				'RIGHT',
				'ROUNDED',
				'RUN',
				'SAME',
				'SD',
				'SEARCH',
				'SECTION',
				'SECURITY',
				'SEGMENT',
				'SEGMENTLIMIT',
				'SELECT',
				'SEND',
				'SENTENCE',
				'SEPARATE',
				'SEQUENCE',
				'SEQUENTIAL',
				'SET',
				'SIGN',
				'SIZE',
				'SORT',
				'SORTMERGE',
				'SOURCE',
				'SOURCECOMPUTER',
				'SPACE',
				'SPACES',
				'SPECIALNAMES',
				'STANDARD',
				'STANDARD1',
				'STANDARD2',
				'START',
				'STATUS',
				'STOP',
				'STRING',
				'SUBQUEUE1',
				'SUBQUEUE2',
				'SUBQUEUE3',
				'SUBTRACT',
				'SUM',
				'SUPER',
				'SUPPRESS',
				'SYMBOLIC',
				'SYNC',
				'SYNCHRONIZED',
				'TALLYING',
				'TAPE',
				'TERMINAL',
				'TERMINATE',
				'TEST',
				'TEXT',
				'THAN',
				'THEN',
				'THROUGH',
				'THRU',
				'TIME',
				'TIMES',
				'TO',
				'TOP',
				'TRAILING',
				'TRUE',
				'TYPE',
				'UNIT',
				'UNSTRING',
				'UNTIL',
				'UP',
				'UPON',
				'USAGE',
				'USE',
				'USING',
				'VALUE',
				'VALUES',
				'VARYING',
				'WHEN',
				'WITH',
				'WORDS',
				'WORKINGSTORAGE',
				'WRITE',
				'ZERO',
				'ZEROES',
				'ZEROS',
			],
			'spec' => [
				'comment' => ('^[\d ]*\*', '$'),
				'string'  => ('"',         '"'),
			],
			'typemap' => {
				'd' => 'data item',
				'f' => 'file description',
				'g' => 'group item',
				'p' => 'paragraph',
				'P' => 'program id',
				's' => 'section',
			},
			'langid' => '6',
		},
		'Perl' => {
			'reserved' => [ 'sub', ],
			'spec'     => [
				'atom'    => ('\$\W?',        ''),
				'atom'    => ('\\\\.',        ''),
				'include' => ('\buse\s+',     ';'),
				'include' => ('\brequire\s+', ';'),
				'string'  => ('"',            '"'),
				'comment' => ('#',            "\$"),
				'comment' => ("^=\\w+",       "^=cut"),
				'string'  => ("'",            "'")
			],
			'typemap' => {
				'l' => 'label',
				'p' => 'package',
				's' => 'subroutine',
			},
			'langid' => '7',

		},
		'Python' => {
			'reserved' => [
				'def',    'print',  'del',     'pass',  'break',  'continue',
				'return', 'raise',  'import',  'from',  'global', 'exec',
				'assert', 'if',     'elif',    'else',  'while',  'for',
				'try',    'except', 'finally', 'class', 'as',     'import',
				'or',     'and',    'is',      'in',    'for',    'if',
				'not',    'lambda', 'self',
			],

			'spec' => [
				'comment' => ('#',     "\$"),
				'string'  => ('"',     '"'),
				'string'  => ("'",     "'"),
				'atom'    => ('\\\\.', '')
			],
			'typemap' => {
				'c' => 'class',
				'f' => 'function',
				'm' => 'class member',
			},
			'langid' => '8',
		},
		'php' => {
			'reserved' => [
				'and',             '$argv',            '$argc',            'break',
				'case',            'class',            'continue',         'default',
				'do',              'die',              'echo',             'else',
				'elseif',          'empty',            'endfor',           'endforeach',
				'endif',           'endswitch',        'endwhile',         'E_ALL',
				'E_PARSE',         'E_ERROR',          'E_WARNING',        'exit',
				'extends',         'FALSE',            'for',              'foreach',
				'function',        'HTTP_COOKIE_VARS', 'HTTP_GET_VARS',    'HTTP_POST_VARS',
				'HTTP_POST_FILES', 'HTTP_ENV_VARS',    'HTTP_SERVER_VARS', 'if',
				'global',          'list',             'new',              'not',
				'NULL',            'or',               'parent',           'PHP_OS',
				'PHP_SELF',        'PHP_VERSION',      'print',            'return',
				'static',          'switch',           'stdClass',         'this',
				'TRUE',            'var',              'xor',              'virtual',
				'while',           '__FILE__',         '__LINE__',         '__sleep',
				'__wakeup',
			],

			'spec' => [
				'comment', '/\*',          '\*/',          'comment',
				'//',      "\$",           'comment',      '#',
				"\$",      'string',       '"',            '"',
				'string',  "'",            "'",            'include',
				'require', "\$",           'include',      'include',
				"\$",      'include',      'require_once', "\$",
				'include', 'include_once', "\$"
			],
			'typemap' => {
				'c' => 'class',
				'f' => 'function',
			},
			'langid' => '9',
		},
		'Make' => {
			'reserved' => {},
			'spec'     => [
				'comment' => ('#',            "\$"),
				'string'  => ('"',            '"'),
				'string'  => ("'",            "'"),
				'include' => ('^ *-?include', '\$')
			],
			'typemap' => { 'm' => 'macro', },
			'langid'  => '10',
		},
		'SQL' => {
			'reserved' => [

				# some oracle reserved words
				'SYSDATE',
				'SEQUENCE',
				'SYNONYM',

				# sql 89, 92, and 99 reserved words
				'ABSOLUTE',
				'ACTION',
				'ADD',
				'AFTER',
				'ALL',
				'ALLOCATE',
				'ALTER',
				'AND',
				'ANY',
				'ARE',
				'ARRAY',
				'AS',
				'ASC',
				'ASENSITIVE',
				'ASSERTION',
				'ASYMMETRIC',
				'AT',
				'ATOMIC',
				'AUTHORIZATION',
				'AVG',
				'BEFORE',
				'BEGIN',
				'BETWEEN',
				'BIGINT',
				'BINARY',
				'BIT',
				'BIT_LENGTH',
				'BLOB',
				'BOOLEAN',
				'BOTH',
				'BREADTH',
				'BY',
				'CALL',
				'CALLED',
				'CASCADE',
				'CASCADED',
				'CASE',
				'CAST',
				'CATALOG',
				'CHAR',
				'CHAR_LENGTH',
				'CHARACTER',
				'CHARACTER_LENGTH',
				'CHECK',
				'CLOB',
				'CLOSE',
				'COALESCE',
				'COLLATE',
				'COLLATION',
				'COLUMN',
				'COMMIT',
				'CONDITION',
				'CONNECT',
				'CONNECTION',
				'CONSTRAINT',
				'CONSTRAINTS',
				'CONSTRUCTOR',
				'CONTAINS',
				'CONTINUE',
				'CONVERT',
				'CORRESPONDING',
				'COUNT',
				'CREATE',
				'CROSS',
				'CUBE',
				'CURRENT',
				'CURRENT_DATE',
				'CURRENT_DEFAULT_TRANSFORM_GROUP',
				'CURRENT_PATH',
				'CURRENT_ROLE',
				'CURRENT_TIME',
				'CURRENT_TIMESTAMP',
				'CURRENT_TRANSFORM_GROUP_FOR_TYPE',
				'CURRENT_USER',
				'CURSOR',
				'CYCLE',
				'DATA',
				'DATE',
				'DAY',
				'DEALLOCATE',
				'DEC',
				'DECIMAL',
				'DECLARE',
				'DEFAULT',
				'DEFERRABLE',
				'DEFERRED',
				'DELETE',
				'DEPTH',
				'DEREF',
				'DESC',
				'DESCRIBE',
				'DESCRIPTOR',
				'DETERMINISTIC',
				'DIAGNOSTICS',
				'DISCONNECT',
				'DISTINCT',
				'DO',
				'DOMAIN',
				'DOUBLE',
				'DROP',
				'DYNAMIC',
				'EACH',
				'ELEMENT',
				'ELSE',
				'ELSEIF',
				'END',
				'EQUALS',
				'ESCAPE',
				'EXCEPT',
				'EXCEPTION',
				'EXEC',
				'EXECUTE',
				'EXISTS',
				'EXIT',
				'EXTERNAL',
				'EXTRACT',
				'FALSE',
				'FETCH',
				'FILTER',
				'FIRST',
				'FLOAT',
				'FOR',
				'FOREIGN',
				'FOUND',
				'FREE',
				'FROM',
				'FULL',
				'FUNCTION',
				'GENERAL',
				'GET',
				'GLOBAL',
				'GO',
				'GOTO',
				'GRANT',
				'GROUP',
				'GROUPING',
				'HANDLER',
				'HAVING',
				'HOLD',
				'HOUR',
				'IDENTITY',
				'IF',
				'IMMEDIATE',
				'IN',
				'INDICATOR',
				'INITIALLY',
				'INNER',
				'INOUT',
				'INPUT',
				'INSENSITIVE',
				'INSERT',
				'INT',
				'INTEGER',
				'INTERSECT',
				'INTERVAL',
				'INTO',
				'IS',
				'ISOLATION',
				'ITERATE',
				'JOIN',
				'KEY',
				'LANGUAGE',
				'LARGE',
				'LAST',
				'LATERAL',
				'LEADING',
				'LEAVE',
				'LEFT',
				'LEVEL',
				'LIKE',
				'LOCAL',
				'LOCALTIME',
				'LOCALTIMESTAMP',
				'LOCATOR',
				'LOOP',
				'LOWER',
				'MAP',
				'MATCH',
				'MAX',
				'MEMBER',
				'MERGE',
				'METHOD',
				'MIN',
				'MINUTE',
				'MODIFIES',
				'MODULE',
				'MONTH',
				'MULTISET',
				'NAMES',
				'NATIONAL',
				'NATURAL',
				'NCHAR',
				'NCLOB',
				'NEW',
				'NEXT',
				'NO',
				'NONE',
				'NOT',
				'NULL',
				'NULLIF',
				'NUMERIC',
				'OBJECT',
				'OCTET_LENGTH',
				'OF',
				'OLD',
				'ON',
				'ONLY',
				'OPEN',
				'OPTION',
				'OR',
				'ORDER',
				'ORDINALITY',
				'OUT',
				'OUTER',
				'OUTPUT',
				'OVER',
				'OVERLAPS',
				'PAD',
				'PARAMETER',
				'PARTIAL',
				'PARTITION',
				'PATH',
				'POSITION',
				'PRECISION',
				'PREPARE',
				'PRESERVE',
				'PRIMARY',
				'PRIOR',
				'PRIVILEGES',
				'PROCEDURE',
				'PUBLIC',
				'RANGE',
				'READ',
				'READS',
				'REAL',
				'RECURSIVE',
				'REF',
				'REFERENCES',
				'REFERENCING',
				'RELATIVE',
				'RELEASE',
				'REPEAT',
				'RESIGNAL',
				'RESTRICT',
				'RESULT',
				'RETURN',
				'RETURNS',
				'REVOKE',
				'RIGHT',
				'ROLE',
				'ROLLBACK',
				'ROLLUP',
				'ROUTINE',
				'ROW',
				'ROWS',
				'SAVEPOINT',
				'SCHEMA',
				'SCOPE',
				'SCROLL',
				'SEARCH',
				'SECOND',
				'SECTION',
				'SELECT',
				'SENSITIVE',
				'SESSION',
				'SESSION_USER',
				'SET',
				'SETS',
				'SIGNAL',
				'SIMILAR',
				'SIZE',
				'SMALLINT',
				'SOME',
				'SPACE',
				'SPECIFIC',
				'SPECIFICTYPE',
				'SQL',
				'SQLCODE',
				'SQLERROR',
				'SQLEXCEPTION',
				'SQLSTATE',
				'SQLWARNING',
				'START',
				'STATE',
				'STATIC',
				'SUBMULTISET',
				'SUBSTRING',
				'SUM',
				'SYMMETRIC',
				'SYSTEM',
				'SYSTEM_USER',
				'TABLE',
				'TABLESAMPLE',
				'TEMPORARY',
				'THEN',
				'TIME',
				'TIMESTAMP',
				'TIMEZONE_HOUR',
				'TIMEZONE_MINUTE',
				'TO',
				'TRAILING',
				'TRANSACTION',
				'TRANSLATE',
				'TRANSLATION',
				'TREAT',
				'TRIGGER',
				'TRIM',
				'TRUE',
				'UNDER',
				'UNDO',
				'UNION',
				'UNIQUE',
				'UNKNOWN',
				'UNNEST',
				'UNTIL',
				'UPDATE',
				'UPPER',
				'USAGE',
				'USER',
				'USING',
				'VALUE',
				'VALUES',
				'VARCHAR',
				'VARYING',
				'VIEW',
				'WHEN',
				'WHENEVER',
				'WHERE',
				'WHILE',
				'WINDOW',
				'WITH',
				'WITHIN',
				'WITHOUT',
				'WORK',
				'WRITE',
				'YEAR',
				'ZONE',
			],

			'spec' => [
				'comment', '/\*', '\*/', 'comment', '//',    "\$",
				'comment', '--',  "\$",  'string',  '"',     '"',
				'string',  "'",   "'",   'atom',    '\\\\.', '',
			],
			'typemap' => {
				'c' => 'constraint',
				'C' => 'cursor',
				'f' => 'field',
				'F' => 'function',
				'i' => 'index',
				'p' => 'package',
				'P' => 'procedure',
				's' => 'sequence',
				'S' => 'synonym',
				't' => 'table',
				'T' => 'trigger',
				'v' => 'view',
			},
			'langid' => '11',
		},
		'VB' => {
			'reserved' => [
				'AddHandler',  'AddressOf',      'Alias',          'And',
				'AndAlso',     'Ansi',           'As',             'Assembly',
				'Auto',        'Boolean',        'ByRef',          'Byte',
				'ByVal',       'Call',           'Case',           'Catch',
				'CBool',       'CByte',          'CChar',          'CDate',
				'CDec',        'CDbl',           'Char',           'CInt',
				'Class',       'CLng',           'CObj',           'Const',
				'CShort',      'CSng',           'CStr',           'CType',
				'Date',        'Decimal',        'Declare',        'Default',
				'Delegate',    'Dim',            'DirectCast',     'Do',
				'Double',      'Each',           'Else',           'ElseIf',
				'End',         'Enum',           'Erase',          'Error',
				'Event',       'Exit',           'False',          'Finally',
				'For',         'Friend',         'Function',       'Get',
				'GetType',     'GoSub',          'GoTo',           'Handles',
				'If',          'Implements',     'Imports',        'In',
				'Inherits',    'Integer',        'Interface',      'Is',
				'Let',         'Lib',            'Like',           'Long',
				'Loop',        'Me',             'Mod',            'Module',
				'MustInherit', 'MustOverride',   'MyBase',         'MyClass',
				'Namespace',   'New',            'Next',           'Not',
				'Nothing',     'NotInheritable', 'NotOverridable', 'Object',
				'On',          'Option',         'Optional',       'Or',
				'OrElse',      'Overloads',      'Overridable',    'Overrides',
				'ParamArray',  'Preserve',       'Private',        'Property',
				'Protected',   'Public',         'RaiseEvent',     'ReadOnly',
				'ReDim',       'REM',            'RemoveHandler',  'Resume',
				'Return',      'Select',         'Set',            'Shadows',
				'Shared',      'Short',          'Single',         'Static',
				'Step',        'Stop',           'String',         'Structure',
				'Sub',         'SyncLock',       'Then',           'Throw',
				'To',          'True',           'Try',            'TypeOf',
				'Unicode',     'Until',          'Variant',        'When',
				'While',       'With',           'WithEvents',     'WriteOnly',
				'Xor',
			],
			'spec' => [
				'comment', 'rem ',  '\$', 'comment', "'", "\$",
				'string',  '"',     '"',  'string',  "'", "'",
				'atom',    '\\\\.', '',
			],
			'typemap' => {
				'c' => 'const',
				'e' => 'enum',
				'f' => 'function',
				'l' => 'label',
				'n' => 'name',
				's' => 'subroutine',
				't' => 'type',
				'v' => 'variable',
			},
			'langid' => '12',
		},
		'shell' => {
			'reserved' => [
				'for',  'do',   'done', 'case', 'esac', 'while', 'in', 'if',
				'then', 'else', 'elif', 'fi',   'until',
			],
			'spec' => [ 'comment', '#', '$', 'string', '"', '"', 'string', "'", "'", ],
			'typemap' => { 'f' => 'function', },
			'langid'  => '13',
		},
	  } }
